Node affinity is an advanced feature in Kubernetes that allows you to control where pods are scheduled by setting complex rules for pod placement. While Node Selectors
offer a simpler approach, Node Affinity
provides more flexibility with expressions like In
, NotIn
, and Exists
, giving you greater control over pod placement based on node labels.
Node affinity allows you to control which nodes a pod can be scheduled on by defining affinity rules based on node labels. These rules can be mandatory or preferred, depending on the pod's scheduling requirements. This ensures that workloads are deployed on the correct nodes with specific characteristics such as region, instance type, or resource capacities.
Before using node affinity, you need to label the nodes. Here’s how to label a node:
kubectl label nodes node1 size=large
This command adds the label size=large
to node1
.
Let’s create a pod that uses node affinity to ensure it runs only on nodes labeled size=large
:
apiVersion: v1
kind: Pod
metadata:
name: data-processor
spec:
affinity:
nodeAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
nodeSelectorTerms:
- matchExpressions:
- key: size
operator: In
values:
- large
containers:
- name: data-processor-container
image: data-processor:latest
In this example, the pod will only be scheduled on nodes with the label size=large
. The In
operator allows us to specify a list of values, but in this case, we are only targeting nodes labeled large
.
To check if the pod is scheduled correctly, run:
kubectl get pods -o wide
Node affinity supports a variety of operators that can be used to define scheduling rules:
apiVersion: v1
kind: Pod
metadata:
name: data-processor
spec:
affinity:
nodeAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
nodeSelectorTerms:
- matchExpressions:
- key: size
operator: In
values:
- large
- medium
- key: region
operator: In
values:
- us-west-1
containers:
- name: data-processor-container
image: data-processor:latest
In this example, the pod will only be scheduled on nodes that have the label size
set to either large
or medium
and the label region
set to us-west-1
.
In
, NotIn
, and Exists
.PreferredDuringSchedulingIgnoredDuringExecution
when pod placement is not crucial, but you still want to guide the scheduler toward specific nodes. For critical workloads, use RequiredDuringSchedulingIgnoredDuringExecution
to ensure that pods are scheduled on the right nodes.
Imagine you have a large data processing application that needs to run on nodes with significant CPU and memory resources. You can use node affinity to ensure that the pods are scheduled on large compute nodes, ensuring they get the resources they need.
kubectl label nodes compute-node-1 size=large
apiVersion: v1
kind: Pod
metadata:
name: big-data-app
spec:
affinity:
nodeAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
nodeSelectorTerms:
- matchExpressions:
- key: size
operator: In
values:
- large
containers:
- name: big-data-container
image: big-data-app:latest
Node affinity gives you more control over where your pods are placed in a Kubernetes cluster. It allows you to define rules for pod scheduling based on node labels and is especially useful in heterogeneous environments with diverse node resources. However, it requires careful configuration, and its flexibility comes with some complexity. As Kubernetes continues to evolve, additional node affinity features may be introduced, such as handling changes during pod execution.